/**
 * @file thread1.c
 * @brief WiFi热点管理线程实现
 * 
 * 该线程负责WiFi热点的创建、监控和维护。主要功能包括：
 * 1. 从配置文件读取WiFi热点配置信息（名称、密码、IP地址）
 * 2. 初始化并启动WiFi热点
 * 3. 定期检查WiFi热点状态，确保其正常运行
 * 4. 在热点异常时进行重启
 * 5. 处理来自其他线程的WiFi重置请求
 * 
 * @note 该线程是系统网络通信的基础，确保控制器能够与外部设备进行通信
 * 
 * @author 伞控无人机项目组
 * @date 2023
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#include <time.h>
#include "thread1.h"
#include "msg_queue.h"

// 统一使用 LOG_MODULE_WIFI（定义见 log_modules.h），不再在本文件重复定义

#define CONFIG_FILE "device_config.txt"
#define MAX_CMD_LEN 256
#define MAX_WIFI_NAME_LEN 64
#define MAX_WIFI_PASS_LEN 64
#define MAX_IP_ADDR_LEN 20
#define CHECK_INTERVAL 30  // 检查WiFi状态的间隔（秒）

// WiFi热点状态定义由头文件 thread1.h 提供

// 全局变量，表示WiFi热点状态
int g_wifi_hotspot_status = WIFI_HOTSPOT_FAILURE;

// 从配置文件中获取WiFi配置信息
static int get_wifi_config(char *wifi_name, char *wifi_pass, char *ip_address, int name_max_len, int pass_max_len, int ip_max_len) {
    FILE *fp;
    char line[512];
    char *ptr, *value;
    int name_found = 0;
    int pass_found = 0;
    int ip_found = 0;
    
    fp = fopen(CONFIG_FILE, "r");
    if (fp == NULL) {
        LOG_WARN(LOG_TO_FILE, LOG_MODULE_WIFI, "无法打开配置文件 %s，将使用默认配置", CONFIG_FILE);
        return -1;
    }
    
    // 默认值
    strncpy(wifi_name, "LDCICM_Router", name_max_len - 1);
    wifi_name[name_max_len - 1] = '\0';
    
    strncpy(wifi_pass, "12345678", pass_max_len - 1);
    wifi_pass[pass_max_len - 1] = '\0';
    
    strncpy(ip_address, "192.168.100.1", ip_max_len - 1);
    ip_address[ip_max_len - 1] = '\0';
    
    while (fgets(line, sizeof(line), fp)) {
        // 查找WiFi名称
        ptr = strstr(line, "\"wifi_name\"");
        if (ptr && !name_found) {
            ptr = strchr(ptr + 10, ':');
            if (ptr) {
                ptr++;
                while (isspace(*ptr)) ptr++;
                
                if (*ptr == '"') {
                    value = ++ptr;
                    ptr = strchr(value, '"');
                    if (ptr) {
                        *ptr = '\0';
                        strncpy(wifi_name, value, name_max_len - 1);
                        wifi_name[name_max_len - 1] = '\0';
                        name_found = 1;
                    }
                }
            }
        }
        
        // 查找WiFi密码
        ptr = strstr(line, "\"wifi_password\"");
        if (ptr && !pass_found) {
            ptr = strchr(ptr + 14, ':');
            if (ptr) {
                ptr++;
                while (isspace(*ptr)) ptr++;
                
                if (*ptr == '"') {
                    value = ++ptr;
                    ptr = strchr(value, '"');
                    if (ptr) {
                        *ptr = '\0';
                        strncpy(wifi_pass, value, pass_max_len - 1);
                        wifi_pass[pass_max_len - 1] = '\0';
                        pass_found = 1;
                    }
                }
            }
        }
        
        // 查找IP地址
        ptr = strstr(line, "\"ip_address\"");
        if (ptr && !ip_found) {
            ptr = strchr(ptr + 11, ':');
            if (ptr) {
                ptr++;
                while (isspace(*ptr)) ptr++;
                
                if (*ptr == '"') {
                    value = ++ptr;
                    ptr = strchr(value, '"');
                    if (ptr) {
                        *ptr = '\0';
                        strncpy(ip_address, value, ip_max_len - 1);
                        ip_address[ip_max_len - 1] = '\0';
                        ip_found = 1;
                    }
                }
            }
        }
        
        // 如果都找到了，就可以退出循环
        if (name_found && pass_found && ip_found) {
            break;
        }
    }
    
    fclose(fp);
    return 0;
}

// 执行命令并返回状态码，同时捕获输出
static int execute_cmd(const char *cmd) {
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "执行命令: %s", cmd);
    
    // 使用popen捕获命令输出
    FILE *fp = popen(cmd, "r");
    if (fp == NULL) {
        LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "无法执行命令: %s", cmd);
        return -1;
    }
    
    char buffer[1024];
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        // 移除换行符
        size_t len = strlen(buffer);
        if (len > 0 && buffer[len-1] == '\n') {
            buffer[len-1] = '\0';
        }
        // 只记录非空输出
        if (strlen(buffer) > 0) {
            LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "命令输出: %s", buffer);
        }
    }
    
    int ret = pclose(fp);
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "命令执行结果: %d", ret);
    return ret;
}

// 检查WiFi热点状态
static int check_wifi_status(const char *hotspot_name) {
    char cmd[MAX_CMD_LEN];
    char buffer[1024];
    FILE *fp;
    int found = 0;
    
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "检查WiFi热点状态: %s", hotspot_name);
    
    // 使用nmcli connection show命令检查热点是否存在
    snprintf(cmd, sizeof(cmd), "nmcli connection show | grep %s", hotspot_name);
    
    fp = popen(cmd, "r");
    if (fp == NULL) {
        LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "执行命令失败: %s", cmd);
        return 0;
    }
    
    // 读取命令输出
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        if (strstr(buffer, hotspot_name)) {
            found = 1;
            break;
        }
    }
    
    pclose(fp);
    
    if (found) {
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "热点 %s 存在并正常运行", hotspot_name);
        return 1;
    } else {
        LOG_WARN(LOG_TO_FILE, LOG_MODULE_WIFI, "热点 %s 不存在或未正常运行", hotspot_name);
        return 0;
    }
}

// 初始化WiFi热点
static int init_wifi_hotspot(const char *wifi_name, const char *wifi_pass, const char *ip_address) {
    char cmd[MAX_CMD_LEN];
    int status;
    char ip_with_mask[32];
    char msg_buffer[128];
    
    // 构建IP地址/掩码格式
    snprintf(ip_with_mask, sizeof(ip_with_mask), "%s/24", ip_address);
    
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "开始初始化WiFi热点: %s，IP: %s", 
             wifi_name, ip_address);
    
    // 关闭所有活跃的WiFi连接
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "关闭所有活跃的WiFi连接...");
    status = execute_cmd("nmcli -t con show --active | grep wifi | cut -d: -f1 | xargs -r -n1 nmcli con down");
    sleep(1);
    
    // 删除所有WiFi热点连接
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "删除所有WiFi热点连接...");
    status = execute_cmd("nmcli -t con show | grep hotspot | cut -d: -f1 | xargs -r -n1 nmcli con del");
    sleep(1);
    
    // 确保WiFi功能已开启
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "确保WiFi功能已开启...");
    status = execute_cmd("nmcli r wifi on");
    sleep(1);
    
    // 创建WiFi热点
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "创建WiFi热点...");
    snprintf(cmd, sizeof(cmd), "nmcli con add type wifi ifname wlan0 mode ap con-name %s ssid %s", 
             wifi_name, wifi_name);
    status = execute_cmd(cmd);
    if (status != 0) {
        LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "创建WiFi热点失败");
        g_wifi_hotspot_status = WIFI_HOTSPOT_FAILURE;
        return -1;
    }
    sleep(1);
    
    // 设置热点频段
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置热点频段...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s 802-11-wireless.band bg", wifi_name);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置AP热点模式
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置AP热点模式...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s 802-11-wireless.mode ap", wifi_name);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置IP地址
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置IP地址...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s ipv4.addresses %s", wifi_name, ip_with_mask);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置密钥管理方式
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置密钥管理方式...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s 802-11-wireless-security.key-mgmt wpa-psk", wifi_name);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置WPA协议
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置WPA协议...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s 802-11-wireless-security.proto wpa", wifi_name);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置加密方式
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置加密方式...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s 802-11-wireless-security.pairwise ccmp", wifi_name);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置WiFi密码
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置WiFi密码...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s 802-11-wireless-security.psk %s", wifi_name, wifi_pass);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 设置网络共享模式
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "设置网络共享模式...");
    snprintf(cmd, sizeof(cmd), "nmcli con modify %s ipv4.method shared", wifi_name);
    status = execute_cmd(cmd);
    sleep(1);
    
    // 启动热点
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "启动WiFi热点: %s", wifi_name);
    snprintf(cmd, sizeof(cmd), "nmcli c up %s", wifi_name);
    status = execute_cmd(cmd);
    if (status != 0) {
        LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "启动热点失败");
        g_wifi_hotspot_status = WIFI_HOTSPOT_FAILURE;
        return -1;
    }
    sleep(2);
    
    // 验证热点是否成功启动
    if (check_wifi_status(wifi_name)) {
        LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "WiFi热点初始化成功，名称: %s，IP: %s", 
                 wifi_name, ip_address);
        g_wifi_hotspot_status = WIFI_HOTSPOT_SUCCESS;
        
        // 发送WiFi热点重置消息
        snprintf(msg_buffer, sizeof(msg_buffer), 
                 "WiFi热点已重新建立，名称: %s，时间: %ld", 
                 wifi_name, time(NULL));
        
        if (send_msg(g_msg_queue_id, MSG_TYPE_WIFI_RESET, msg_buffer) != 0) {
            LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "发送WiFi热点重置消息失败");
        } else {
            LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "已发送WiFi热点重置消息到消息队列");
        }
        
        return 0;
    } else {
        LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "WiFi热点初始化失败");
        g_wifi_hotspot_status = WIFI_HOTSPOT_FAILURE;
        return -1;
    }
}

// 线程1函数实现 - WiFi热点管理
void *thread1_function(void *arg) {
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "线程1启动: WiFi管理");
    (void)arg;
    char wifi_name[MAX_WIFI_NAME_LEN] = {0};
    char wifi_pass[MAX_WIFI_PASS_LEN] = {0};
    char ip_address[MAX_IP_ADDR_LEN] = {0};
    int hotspot_active = 0;
    int retry_count = 0;
    int was_active = 0;  // 记录上一次热点是否是活跃的
    
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "WiFi热点管理线程启动");
    
    // 从配置文件读取WiFi名称、密码和IP地址
    if (get_wifi_config(wifi_name, wifi_pass, ip_address, sizeof(wifi_name), sizeof(wifi_pass), sizeof(ip_address)) != 0) {
        LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "无法读取WiFi配置，使用默认值");
    }
    
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "配置的WiFi名称: %s", wifi_name);
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "配置的WiFi密码已读取");
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "配置的IP地址: %s", ip_address);
    
    // 初始化创建WiFi热点（最多尝试3次）
    while (retry_count < 3 && !hotspot_active) {
        if (init_wifi_hotspot(wifi_name, wifi_pass, ip_address) == 0) {
            hotspot_active = 1;
            was_active = 1;
            LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "WiFi热点创建成功");
            break;
        } else {
            retry_count++;
            if (retry_count < 3) {
                LOG_WARN(LOG_TO_FILE, LOG_MODULE_WIFI, "热点创建失败，尝试第 %d 次重试...", retry_count + 1);
                sleep(2);
            } else {
                LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "多次尝试后热点创建失败");
            }
        }
    }
    
    // 主循环：监控WiFi状态
    while (1) {
        // 检查WiFi热点状态
        if (!check_wifi_status(wifi_name)) {
            LOG_WARN(LOG_TO_FILE, LOG_MODULE_WIFI, "WiFi热点异常，尝试重新建立");
            
            // 热点状态从活跃变为不活跃
            if (was_active) {
                g_wifi_hotspot_status = WIFI_HOTSPOT_FAILURE;
                was_active = 0;
            }
            
            // 尝试重新初始化热点
            retry_count = 0;
            while (retry_count < 3) {
                if (init_wifi_hotspot(wifi_name, wifi_pass, ip_address) == 0) {
                    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "热点重新创建成功");
                    was_active = 1;
                    break;
                }
                
                retry_count++;
                if (retry_count < 3) {
                    LOG_WARN(LOG_TO_FILE, LOG_MODULE_WIFI, "重新创建热点失败，尝试第 %d 次重试...", retry_count + 1);
                    sleep(2);
                } else {
                    LOG_ERROR(LOG_TO_FILE, LOG_MODULE_WIFI, "多次尝试后热点重新创建失败，将稍后再试");
                }
            }
        } else {
            LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_WIFI, "WiFi热点正常运行中，名称: %s，IP: %s", 
                      wifi_name, ip_address);
        }
        
        // 休眠指定时间
        sleep(CHECK_INTERVAL);
    }
    
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "线程1退出");
    return NULL;
}

void thread1_stop(void) {
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_WIFI, "线程1停止中");
    // 这里可以添加停止逻辑
} 